【SFA官方翻译】通过 Zuul 进行动态路由

通过 Zuul 进行动态路由使用 REST API 和没有 Spring Config 的 Spring Boot 子域子路径路由器

原文链接：https://dzone.com/articles/dynamic-routing-through-zuul-with-rest-api-spring

作者：Vikas Anand

译者：umbrellage

问题陈述

有一个要求，把所有的流量都转到 .adomain.com到 adomain.com/*。例如: a.adomain.com/**/*应该转发到 adomain.com/a/**/*。此外，代理网关应该一直处于运行状态，并且需要在网关中注册新的子域，而不需要任何停机时间。这是一个非常具体的问题，需要一些研究来达到同样的目的。

代理的研究

我们尝试了几个方面，包括节点 http-proxy，Java throo 库（内部使用Zuul）和 Zuul 本身。 所有示例都基于来自用于代理创建的属性文件的预取配置，除了先前的 Zuul 示例，其中讨论了使用 Spring 可刷新云配置和 RabbitMQ 的可刷新配置。 需要运行时代理创建器服务，优选地暴露 POST API 以获取一些参数并在运行时注册新代理。甚至还需要删除 API 来摆脱不再使用的代理。作为 Java 开发人员，自然选择是 Zuul。

先决条件

需要了解 Java、api、代理、Apache、网关概念和 Spring Boot，才能完全理解本文提出的概念。

解决方案

通过 Netflix 提供的 Zuul，现在添加了Spring Cloud分布 ，关于如何使用 Eureka、Zuul 服务器、Spring Cloud 服务器、RabbitMQ 和 Git，有一个很好的例子。 尽管整个示例非常棒，并且提供了很大的灵活性，但它涉及到许多框架和许多需要完成的设置。 我不能使用它，因为我想创建一个非常简单的解决方案来解决我们的问题，考虑到不成为 HA 的权衡。

架构如下:

编码

要使应用程序正常工作，还需要做几件事：

接口

在 POST 中使用参数来创建路由。

Zuul-Related变化

• Pom 更改：它包含执行器，zuul 和与 spring-cloud 相关的依赖项。

1. <project

2.    xmlns="http://maven.apache.org/POM/4.0.0"

3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

5.    <modelVersion>4.0.0</modelVersion>

6.    <groupId>com.example</groupId>

7.    <artifactId>gateway-service</artifactId>

8.    <version>0.0.1-SNAPSHOT</version>

9.    <parent>

10.        <groupId>org.springframework.boot</groupId>

11.        <artifactId>spring-boot-starter-parent</artifactId>

12.        <version>1.4.7.RELEASE</version>

13.        <relativePath />

14.        <!-- lookup parent from repository -->

15.    </parent>

16.    <properties>

17.        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

18.        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

19.        <java.version>1.8</java.version>

20.        <!-- Dependencies -->

21.        <spring-cloud.version>Camden.SR7</spring-cloud.version>

22.    </properties>

23.    <dependencyManagement>

24.        <dependencies>

25.            <dependency>

26.                <groupId>org.springframework.cloud</groupId>

27.                <artifactId>spring-cloud-dependencies</artifactId>

28.                <version>${spring-cloud.version}</version>

29.                <type>pom</type>

30.                <scope>import</scope>

31.            </dependency>

32.        </dependencies>

33.    </dependencyManagement>

34.    <dependencies>

35.        <dependency>

36.            <groupId>org.springframework.cloud</groupId>

37.            <artifactId>spring-cloud-starter-zuul</artifactId>

38.        </dependency>

39.        <dependency>

40.            <groupId>org.springframework.boot</groupId>

41.            <artifactId>spring-boot-starter-actuator</artifactId>

42.            <exclusions>

43.                <exclusion>

44.                    <groupId>org.springframework.boot</groupId>

45.                    <artifactId>spring-boot-starter-logging</artifactId>

46.                </exclusion>

47.            </exclusions>

48.        </dependency>

49.        <dependency>

50.            <groupId>org.springframework.boot</groupId>

51.            <artifactId>spring-boot-starter-log4j2</artifactId>

52.        </dependency>

53.        <dependency>

54.            <groupId>org.springframework.boot</groupId>

55.            <artifactId>spring-boot-starter-security</artifactId>

56.        </dependency>

57.        <dependency>

58.            <groupId>org.springframework.boot</groupId>

59.            <artifactId>spring-boot-starter-web</artifactId>

60.        </dependency>

61.    </dependencies>

62.    <build>

63.        <plugins>

64.            <plugin>

65.                <artifactId>maven-compiler-plugin</artifactId>

66.                <configuration>

67.                    <source>1.8</source>

68.                    <target>1.8</target>

69.                </configuration>

70.            </plugin>

71.            <plugin>

72.                <artifactId>maven-shade-plugin</artifactId>

73.                <executions>

74.                    <execution>

75.                        <phase>package</phase>

76.                        <goals>

77.                            <goal>shade</goal>

78.                        </goals>

79.                        <configuration>

80.                            <transformers>

81.                                <transformer

82. implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">

83.                                    <resource>META-INF/spring.handlers</resource>

84.                                </transformer>

85.                                <transformer

86. implementation="org.springframework.boot.maven.PropertiesMergingResourceTransformer">

87.                                    <resource>META-INF/spring.factories</resource>

88.                                </transformer>

89.                                <transformer

90. implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">

91.                                    <resource>META-INF/spring.schemas</resource>

92.                                </transformer>

93.                                <transformer

94. implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />

95.                                <transformer

96. implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">

97.                                    <mainClass>com.example.application.SpringBootWebApplication</mainClass>

98.                                </transformer>

99.                            </transformers>

100.                        </configuration>

101.                    </execution>

102.                </executions>

103.            </plugin>

104.        </plugins>

105.    </build>

106. </project>

Spring Boot 启动类：

1. package com.mettl.gatewayservice.application;

2. import org.springframework.boot.SpringApplication;

3. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

4. import org.springframework.boot.autoconfigure.SpringBootApplication;

5. import org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration;

6. import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

7. import org.springframework.context.annotation.ComponentScan;

8. @SpringBootApplication

9. @EnableAutoConfiguration(exclude = { RabbitAutoConfiguration.class })

10. @EnableZuulProxy

11. @ComponentScan("com.example.gatewayservice")

12. public class SpringBootWebApplication {

13.    public static void main(String[] args) {

14.        SpringApplication.run(SpringBootWebApplication.class, args);

15.    }

16. }

application.yml

1. server:

2.  port: ${appPort:80}

3. info.app.version: @project.version@

4. # Actuator endpoint path (/admin/info, /admin/health, ...)

5. server.servlet-path: /

6. management.context-path: /admin

7. # ribbon.eureka.enabled: false

8. zuul:

9.  ignoredPatterns: /**/admin/**, /proxyurl

10.  routes:

11.    zuulDemo1:

12.      path: /**

13.      url: http://localhost:8000/

14. # stripPrefix set to true if context path is set to /

15.      stripPrefix: true

有两个部分：

1.代理路由的注册

这部分是通过自动连接两个依赖项来创建服务类来完成的，如下所示：

1. @Service    

2. public class ZuulDynamicRoutingService {        

3. private static final String HTTP = "http://";        

4. private final ZuulProperties zuulProperties;        

5. private final ZuulHandlerMapping zuulHandlerMapping;

6.  ......

通过以下代码添加新路由。

可以通过遵循任何标准方式来创建uuid。唯一的问题是它应该是一个唯一的密钥，因为它将被用于所使用的地图中 zuulProperties.getRoutes()。

1. String uuid = GenerateUID.getUID();

2. if (StringUtils.isEmpty(dynamicRouteRequest.getSubpath())) {

3.    dynamicRouteRequest.setSubpath("");

4. }

5. String url = "http://" + dynamicRouteRequest.getHost() + ":" + dynamicRouteRequest.getPort() + dynamicRouteRequest.getSubpath();

6. zuulProperties.getRoutes().put(uuid, new ZuulRoute(uuid, "/" + uuid + "/**", null, url, true, false, new HashSet<>()));

7. zuulHandlerMapping.setDirty(true);

此服务注入控制器以接收发布请求并将详细信息转发到服务类以创建代理。

可以使用 URL / admin / routes 检查它。

2.使用子域到子路径转换将HTTP请求转发到目标

这需要一个扩展 ZuulFilter 的 PreFilter 类：

1. @Component

2. public class PreFilter extends ZuulFilter {

3.  private static Logger log = LoggerFactory.getLogger(PreFilter.class);

4.  private UrlPathHelper urlPathHelper = new UrlPathHelper();

5.  @Override

6.  public String filterType() {

7.      return "pre";

8.  }

9.  @Override

10.  public int filterOrder() {

11.      return 1;

12.  }

13.  @Override

14.  public boolean shouldFilter() {

15.      RequestContext ctx = RequestContext.getCurrentContext();

16.      String requestURL = ctx.getRequest().getRequestURL().toString();

17.      //Here we only require to filter those URLs which contains "proxyurl" and "/admin/".

18.      return !(requestURL.contains("proxyurl") || requestURL.contains("/admin/"));

19.  }

20.  //The actual part where the subdomain to subpath conversion happens is as follows:

21.  @Override

22.  public Object run() {

23.      RequestContext ctx = RequestContext.getCurrentContext();

24.      String remoteHost = ctx.getRequest().getRemoteHost();

25.      String requestURL = ctx.getRequest().getRequestURL().toString();

26.      if (!requestURL.contains("proxyurl")) {

27.          log.info("remoteHost {} requestURL {}", new Object[]{remoteHost, requestURL});

28.          String originatingRequestUri = this.urlPathHelper.getOriginatingRequestUri(ctx.getRequest());

29.          final String requestURI = this.urlPathHelper.getPathWithinApplication(ctx.getRequest());

30.          log.info("URI {} original URI {}", new Object[]{requestURI, originatingRequestUri});

31.          String protocol = requestURL.substring(0, requestURL.indexOf("//") + 2);

32.          String urlWithoutProtocol = requestURL.substring(requestURL.indexOf("//") + 2);

33.          String[] split = urlWithoutProtocol.substring(0, urlWithoutProtocol.indexOf("/")).split("\\.");

34.          String subPath = split[0];

35.          final String newURL = protocol + "." + split[1] + "." + split[2];

36.          //Here the main thing is to create a HttpServletRequestWrapper and override the request coming from the actual request

37.          HttpServletRequestWrapper httpServletRequestWrapper = new HttpServletRequestWrapper(ctx.getRequest()) {

38.              public String getRequestURI() {

39.                  if (requestURI != null && !requestURI.equals("/")) {

40.                      if (!StringUtils.isEmpty(subPath)) {

41.                          return "/" + subPath + requestURI;

42.                      } else {

43.                          return requestURI;

44.                      }

45.                  }

46.                  if (!StringUtils.isEmpty(subPath)) {

47.                      return "/" + subPath;

48.                  } else {

49.                      return "/";

50.                  }

51.              }

52.              public StringBuffer getRequestURL() {

53.                return new StringBuffer(newURL);

54.              }

55.          };

56.          ctx.setRequest(httpServletRequestWrapper);

57.          HttpServletRequest request = ctx.getRequest();

58.          log.info("PreFilter: " + String.format("%s request to %s", request.getMethod(), request.getRequestURL().toString()));

59.       }

60.       return null;

61.    }

62. }

现在，您可以通过使用 mvn springboot:run 或 添加缺少的部分来运行应用程序 java-jar gateway-service.jar。

现在，使用 Postman 提交请求，如下所示。

去做你自己的事

• 此会话中缺少 Apache 部分。添加配置以将来自 * .adomain.com 的所有请求转发到托管 Zuul 服务器的 IP，并在启动 Zuul 服务器时配置端口。

• 在创建代理路由以实际查看正在发生的情况时需要启动请求的应用程序。

概要

我们学会了

1. 通过公开 API 在运行时创建代理路由

2. 更改 PreFilter（ZuulFilter 的子类）以预处理 HTTP 请求

3. 添加 Apache 配置以将请求转发到 Zuul Gateway

招人：数心，造化心数奇；用心等你...

上一篇：【SFA官方翻译】使用 Docker 进行 Spring Boot 开发

点击阅读原文查看更多

关注公众号